Stone Design/Stone Design.iso/Stone_Friends/Wave/WavesWorld/Examples/eyes/audreye5.wwModel/animationProcs.eve

Text File | 1995-03-22 | 15.0 KB | 450 lines

set blink(agentName) "blinkAgent"
set blink(agentWeight) 1
set blink(howManySeconds) 1
set blink(thetaMin) 190; # need to use this...
set blink(thetaMax) 360
set blink(downU) .4
set blink(upU) .6

proc preBlink {} {  global  scene blink sphere

  set blink(howManySteps) [expr {$blink(howManySeconds) * $scene(ticksPerSecond)}]
  set blink(uIncr)  [expr 1.0/[expr {$blink(howManySteps) - 1}]]
  set blink(initialTheta) $sphere(thetaMax)
  set blink(u) 0

  registerSampleGenerator $blink(agentName) $blink(agentWeight)
  sampleGeneratorIsExecuting $blink(agentName) 1

  synchWithScene
  return
}


proc blinkMotorProgram {u pauseStart pauseStop initialTheta thetaMax} {  global sphere


  # let's say they start off at 90 and 2.0
  # we want to go from 90 to 175 and then back down to 90, and from 2 to 1 and back to 2
  set extent  [expr {$thetaMax - $initialTheta}]

  # for the first half, move incrementally closer to thetaMax
  if {$u <= $pauseStart} \
  {  set sphere(thetaMax) [expr {$initialTheta + ((2 * $u) * $extent)}];
  } \
  {  if {$u < $pauseStop } \
     {  set sphere(thetaMax) $thetaMax;
     } \
     {  set sphere(thetaMax) [expr {$initialTheta + ((1 - $u) * 2 * $extent)}];
     } \
  } \

  return $u
}

proc postBlink {finalTheta} { global  upperLid blink

  set upperLid(rotate) $finalTheta
  synchWithScene
  sampleGeneratorIsExecuting $blink(agentName) 0
  return
}


set sideToSide(agentName) "sideToSideAgent"
set sideToSide(agentWeight) 1
set sideToSide(howManySeconds) 1
set sideToSide(downU) .4
set sideToSide(upU) .6

set sideToSide(min)       0
set sideToSide(max)       1
set sideToSide(duration)  1.5
set sideToSide(varName)  eyeBall(leftRightR)

proc preSideToSide {} {  global  scene sideToSide

  if {[set a [string first "(" $sideToSide(varName)]] == -1} \
  {  global $sideToSide(varName) } \
  {  global [string range $sideToSide(varName) 0 [expr {$a - 1}]] }

  set sideToSide(howManySteps) [expr {$sideToSide(howManySeconds) * $scene(ticksPerSecond)}]
  set sideToSide(uIncr)  [expr 1.0/[expr {$sideToSide(howManySteps) - 1}]]
  set sideToSide(initial) [set $sideToSide(varName)]
  set sideToSide(u) 0
  set distance [expr {($sideToSide(initial) - $sideToSide(min)) + ($sideToSide(max) - $sideToSide(min)) + ($sideToSide(max) - $sideToSide(initial))}]
  set sideToSide(uA) [expr {($sideToSide(initial) - $sideToSide(min)) / $distance}]
  set sideToSide(uB) [expr {(($sideToSide(initial) - $sideToSide(min)) + (1.0 - $sideToSide(min))) / $distance}]

  registerSampleGenerator $sideToSide(agentName) $sideToSide(agentWeight)
  sampleGeneratorIsExecuting $sideToSide(agentName) 1

  synchWithScene
  return
}

# this behavior goes from the starting point to the maximum left
# point, then to the maximum right point, then returns to the initial
# position
# therefore, there are three parts:
# - move from initial position to sideToSideMin.
#   note that initialPosition, by definition, is >= sideToSideMin (since sideToSideMin is the lowest it can turn)
# - move from sideToSideMin to sideToSideMax
# - move from sideToSideMax to initialPosition
#   note that initialPosition, by definition, is <= sideToSideMax (since sideToSideMax is the farthest it can turn)

proc sideToSideMotorProgram {var u uA uB initial min max agentName} {

  if {[set a [string first "(" $var]] == -1} {  global $var } {  global [string range $var 0 [expr {$a - 1}]] }
  if {$u <= $uA} then \
  {  set thisU [expr {$u/$uA}]; setSample $var [expr {lerpDown($thisU, $min, $initial)}] $agentName } \
  elseif {$u <= $uB} \
         {  set thisU [expr {($u-$uA)/($uB-$uA)}]; setSample $var [expr {lerpUp($thisU, $min, $max)}] $agentName } \
         {  set thisU [expr {($u-$uB)/(1.-$uB)}]; setSample $var [expr {lerpDown($thisU, $initial, $max)}] $agentName }

  puts "$u: $thisU: $var == [set $var]"
  return $u
}


proc postSideToSide {finalPosition} {  global sideToSide

  if {[set a [string first "(" $sideToSide(varName)]] == -1} \
  {  global $sideToSide(varName) } \
  {  global [string range $sideToSide(varName) 0 [expr {$a - 1}]] }

  set [set $sideToSide(varName)] $finalPosition
  synchWithScene
  return
}


set dilate(info) "an ephemeral agent"
set dilate(howManySeconds) 1
set dilate(pupilMin) .01
set dilate(pupilMax) .10

proc preDilate {} {

  global  scene dilate eyeBall


  set dilate(howManySteps) [expr {$dilate(howManySeconds) * $scene(ticksPerSecond)}]
  set dilate(uIncr)  [expr 1.0/[expr {$dilate(howManySteps) - 1}]]
  set dilate(pupilMin) $eyeBall(pupilSize)
  set dilate(pupilMax) [expr {$eyeBall(irisSize) * .9}]
  set dilate(extent) [expr {$dilate(pupilMax) - $dilate(pupilMin)}]
  set dilate(u) 0

  synchWithScene
  return
}

proc dilateMotorProgram {u initial extent} {

  global eyeBall


  set eyeBall(pupilSize) [expr {$initial + ($extent * $u)}]

  return $u
}

proc postDilate {finalPupilSize} { global  eyeBall;

  set eyeBall(pupilSize) $finalPupilSize
  synchWithScene
  return
}

set constrict(info) "an ephemeral agent"
set constrict(howManySeconds) 1
set constrict(pupilMin) .01
set constrict(pupilMax) .10

proc preConstrict {} {

  global  scene constrict eyeBall


  set constrict(howManySteps) [expr {$constrict(howManySeconds) * $scene(ticksPerSecond)}]
  set constrict(uIncr)  [expr 1.0/[expr {$constrict(howManySteps) - 1}]]
  set constrict(pupilMin) .01
  set constrict(pupilMax) $eyeBall(pupilSize)
  if {$constrict(pupilMax) <= $constrict(pupilMin)} { error "eye already constricted..."} {}

  set constrict(extent) [expr {$constrict(pupilMax) - $constrict(pupilMin)}]
  set constrict(u) 0

  synchWithScene
  return
}

proc constrictMotorProgram {u  max extent} {

  global eyeBall


  set eyeBall(pupilSize) [expr {$max - ($extent * $u)}]
  return $u
}

proc postConstrict {finalPupilSize} { global  eyeBall;

  set eyeBall(pupilSize) $finalPupilSize
  synchWithScene
  return
}

set goCurrentMinMaxCurrent(varName)    eyeBall(leftRightR)
set goCurrentMinMaxCurrent(agentName)  leftRightR
set goCurrentMinMaxCurrent(agentWeight)  1.0
set goCurrentMinMaxCurrent(min)          0
set goCurrentMinMaxCurrent(max)          1
set goCurrentMinMaxCurrent(duration)     1.5
proc go {} {  global goCurrentMinMaxCurrent
  goCurrentMinMaxCurrent $goCurrentMinMaxCurrent(varName) \
                         $goCurrentMinMaxCurrent(agentName) $goCurrentMinMaxCurrent(agentWeight) \
                         $goCurrentMinMaxCurrent(min) $goCurrentMinMaxCurrent(max) \
                         $goCurrentMinMaxCurrent(duration)
}

proc goCurrentMinMaxCurrent {varName agentName agentWeight {min 0} {max 1} {duration 1.5}} {  global scene text

  if {[set a [string first "(" $varName]] == -1} {  global $varName } {  global [string range $varName 0 [expr {$a - 1}]] }

  set text(line1) "agent: $agentName"
  set text(line2Color) {1 1 1}
  set text(line2) "variable $varName = "
  registerSampleGenerator $agentName $agentWeight
  sampleGeneratorIsExecuting $agentName 1

  set initial [set $varName]
  set distance [expr {($initial - $min) + ($max - $min) + ($max - $initial)}]
  set uA [expr {($initial - $min) / $distance}]
  set uB [expr {((($initial - $min) + (1.0 - $min)) / $distance)}]
  set u 0

  set text(line2Color) {1 0 0}
  while {$u <= $uA} {
    if {$uA} { set thisU [expr {$u/$uA}] } { set thisU 0}
    setSample $varName [expr {lerpDown($thisU, $min, $initial)}] $agentName
    set text(line2) "A: $varName = [set $varName]"
    set u [expr {$u + (1.0/(($duration * $scene(ticksPerSecond)) - 1) * [synchWithScene])}]
  }
  set text(line2Color) {0 1 0}
  while {$u <= $uB} {
    if {$uA != $uB} { set thisU [expr {($u-$uA)/($uB-$uA)}] } { set thisU 0 }
    setSample $varName [expr {lerpUp($thisU, $min, $max)}] $agentName
    set text(line2) "B: $varName = [set $varName]"
    set u [expr {$u + (1.0/(($duration * $scene(ticksPerSecond)) - 1) * [synchWithScene])}]
  }
  set text(line2Color) {0 0 1}
  while {$u < 1} {
    if {$uB != 1} { set thisU [expr {($u-$uB)/(1-$uB)}] } { set thisU 0 }
    setSample $varName [expr {lerpDown($thisU, $initial, $max)}] $agentName
    set text(line2) "C: $varName = [set $varName]"
    set u [expr {$u + (1.0/(($duration * $scene(ticksPerSecond)) - 1) * [synchWithScene])}]
  }

  setSample $varName $initial $agentName
  set text(line1) "agent $agentName is finishing..."
  set text(line2) "C: $varName = [set $varName]"
  synchWithScene
  sampleGeneratorIsExecuting $agentName 0
  set text(line1) ""
  set text(line2Color) {1 1 1}
  set text(line2) ""
  synchWithScene
}

set go2CurrentMinMaxCurrent(varName)    eyeBall(leftRightR)
set go2CurrentMinMaxCurrent(agentName)  leftRightR
set go2CurrentMinMaxCurrent(agentWeight)  1.0
set go2CurrentMinMaxCurrent(min)          0
set go2CurrentMinMaxCurrent(max)          1
set go2CurrentMinMaxCurrent(duration)     1.5
proc go2 {} {  global go2CurrentMinMaxCurrent
  go2CurrentMinMaxCurrent $go2CurrentMinMaxCurrent(varName) \
                         $go2CurrentMinMaxCurrent(agentName) $go2CurrentMinMaxCurrent(agentWeight) \
                         $go2CurrentMinMaxCurrent(min) $go2CurrentMinMaxCurrent(max) \
                         $go2CurrentMinMaxCurrent(duration)
}

proc doIt {u varName agentName uA uB initial min max} {

   if {[set a [string first "(" $varName]] == -1} \
      {  global text $varName } \
      {  global text [string range $varName 0 [expr {$a - 1}]] }

  global slider
  set slider(u) $u
  if {$u <= $uA} {
     if {$uA} { set thisU [expr {$u/$uA}] } { set thisU 0}
     set slider(color) "1 0 0"
     setSample $varName [expr {lerpDown($thisU, $min, $initial)}] $agentName
  }  elseif {$u <= $uB} {
            if {$uA != $uB} { set thisU [expr {($u-$uA)/($uB-$uA)}] } { set thisU 0 }
            set slider(color) "0 1 0"
            setSample $varName [expr {lerpUp($thisU, $min, $max)}] $agentName
     } \
     {      if {$uB != 1} { set thisU [expr {($u-$uB)/(1-$uB)}] } { set thisU 0 }
            set slider(color) "0 0 1"
            setSample $varName [expr {lerpDown($thisU, $initial, $max)}] $agentName
     }
}


proc go2CurrentMinMaxCurrent {varNameList agentName agentWeight minList maxList duration} {  global scene text slider

  # sanity check the arguments; are all the lists the same length?
  if {[llength $varNameList] == [llength $minList] \
                             == [llength $maxList] \
                             == [llength $duration]} {} {error "list length mismatch" "argument lists should all be the same length"}

  set howMany [llength $varNameList]

  # we need to do this to get the initial value(s) of the variable(s) in varList
  for {set i 0} {$i < $howMany} {incr i} {
     set varName [lindex $varNameList $i]
     if {[set a [string first "(" $varName]] == -1} \
        {  global $varName; } \
        {  global [string range $varName 0 [expr {$a - 1}]]; }
  }

  set text(line1) "agent: $agentName"
  set text(line2Color) {1 1 1}
  registerSampleGenerator $agentName $agentWeight
  sampleGeneratorIsExecuting $agentName 1

  for {set i 0} {$i < $howMany} {incr i} { \
    set initial  [set [lindex $varNameList $i]]
    set min      [lindex $minList $i]
    set max      [lindex $maxList $i]
    set distance [expr {($initial - $min) + ($max - $min) + ($max - $initial)}]
    set uA [expr {($initial - $min) / $distance}]
    set uB [expr {((($initial - $min) + (1.0 - $min)) / $distance)}]
    lappend initialList $initial
    lappend minList $min
    lappend maxList $max
    lappend uAList $uA
    lappend uBList $uB
  }

  set u 0

  while {$u < 1} {
    for {set i 0} {$i < $howMany} {incr i} {
       set varName [lindex $varNameList $i]
       set initial [lindex $initialList $i]
       set uA [lindex $uAList $i]
       set uB [lindex $uBList $i]
       set min [lindex $minList $i]
       set max [lindex $maxList $i]
       set slider(min) [format %g $min]
       set slider(max) [format %g $max]
       doIt $u $varName $agentName $uA $uB $initial $min $max
    }
    set u [expr {$u + (1.0/(($duration * $scene(ticksPerSecond)) - 1) * [synchWithScene])}]
  }

  set text(line1) "agent $agentName is finishing..."
  for {set i 0} {$i < $howMany} {incr i} {
     set varName [lindex $varNameList $i]
     set initial [lindex $initialList $i]
     set uA [lindex $uAList $i]
     set uB [lindex $uBList $i]
     set min [lindex $minList $i]
     set max [lindex $maxList $i]
     doIt 1 $varName $agentName $uA $uB $initial $min $max
  }
  synchWithScene
  sampleGeneratorIsExecuting $agentName 0
  set text(line1) ""
  set text(line2Color) {1 1 1}
  set text(line2) ""
  synchWithScene
}

# in this routine, $initial >= $to, so we lerpDown from $initial to $to
proc doDown {u varName agentName initial to} {

   if {[set a [string first "(" $varName]] == -1} \
      {  global text $varName } \
      {  global text [string range $varName 0 [expr {$a - 1}]] }

  global slider
  set slider(u) $u
  set slider(color) "1 0 0"
  setSample $varName [expr {lerpDown($u, $to, $initial)}] $agentName
}

# in this routine, $initial <= $to, so we lerpUp from $initial to $to
proc doUp {u varName agentName initial to} {

   if {[set a [string first "(" $varName]] == -1} \
      {  global text $varName } \
      {  global text [string range $varName 0 [expr {$a - 1}]] }

  global slider
  set slider(u) $u
  set slider(color) "1 0 0"
  setSample $varName [expr {lerpUp($u, $to, $initial)}] $agentName
}

proc goTo {varNameList agentName agentWeight toList duration} {  global scene text slider

  # sanity check the arguments; are all the lists the same length?
  if {[llength $varNameList] == [llength $toList] \
                             == [llength $duration]} {} {error "list length mismatch" "argument lists should all be the same length"}

  set howMany [llength $varNameList]

  # we need to do this to get the initial value(s) of the variable(s) in varList
  for {set i 0} {$i < $howMany} {incr i} {
     set varName [lindex $varNameList $i]
     if {[set a [string first "(" $varName]] == -1} \
        {  global $varName; } \
        {  global [string range $varName 0 [expr {$a - 1}]]; }
  }

  set text(line1) "agent: $agentName"
  set text(line2Color) {1 1 1}
  registerSampleGenerator $agentName $agentWeight
  sampleGeneratorIsExecuting $agentName 1

  for {set i 0} {$i < $howMany} {incr i} { \
    set initial  [set [lindex $varNameList $i]]
    set to      [lindex $toList $i]
    lappend initialList $initial
    lappend toList $to
  }

  set u 0

  while {$u < 1} {
    for {set i 0} {$i < $howMany} {incr i} {
       set varName [lindex $varNameList $i]
       set initial [lindex $initialList $i]
       set to [lindex $toList $i]
       if {$initial < $to} { doUp $u $varname $agentName $initial $to } { doDown $u $varname $agentName $initial $to }
    }
    set u [expr {$u + (1.0/(($duration * $scene(ticksPerSecond)) - 1) * [synchWithScene])}]
  }

  set text(line1) "agent $agentName is finishing..."
  for {set i 0} {$i < $howMany} {incr i} {
     set varName [lindex $varNameList $i]
     set initial [lindex $initialList $i]
     set to [lindex n$List $i]
     doIt 1 $varName $agentName $uA $uB $initial $min $max
     if {$initial < $to} { doUp 1 $varname $agentName $initial $to } { doDown 1 $varname $agentName $initial $to }
  }
  synchWithScene
  sampleGeneratorIsExecuting $agentName 0
  set text(line1) ""
  set text(line2Color) {1 1 1}
  set text(line2) ""
  synchWithScene
}